package config

import (
	"fmt"
	"log"
	"os"
	"path/filepath"

	"gopkg.in/yaml.v2"
)

// ServerConfig 全局配置结构
type ServerConfig struct {
	Server       ServerSettings       `yaml:"server"`
	Database     DatabaseSettings     `yaml:"database"`
	Auth         AuthSettings         `yaml:"auth"`
	Tunnel       TunnelSettings       `yaml:"tunnel"`
	Logging      LoggingSettings      `yaml:"logging"`
	Development  DevelopmentSettings  `yaml:"development"`
	DomainRouter DomainRouterSettings `yaml:"domain_router"` // 域名路由器配置
	DNS          DNSSettings          `yaml:"dns"`           // DNSPod配置
	Tencent      TencentSettings      `yaml:"tencent"`       // 腾讯云配置
}

// ServerSettings 服务器配置
type ServerSettings struct {
	HTTPPort    int    `yaml:"http_port"`
	TunnelPort  int    `yaml:"tunnel_port"`
	HTTP2Port   int    `yaml:"http2_port"`   // HTTP/2隧道端口
	EnableHTTP2 bool   `yaml:"enable_http2"` // 是否启用HTTP/2
	Mode        string `yaml:"mode"`
}

// DatabaseSettings 数据库配置
type DatabaseSettings struct {
	Type         string `yaml:"type"`
	Host         string `yaml:"host"`
	Port         int    `yaml:"port"`
	Username     string `yaml:"username"`
	Password     string `yaml:"password"`
	DBName       string `yaml:"dbname"`
	MaxIdleConns int    `yaml:"max_idle_conns"`
	MaxOpenConns int    `yaml:"max_open_conns"`
}

// AuthSettings 认证配置
type AuthSettings struct {
	Enabled          bool   `yaml:"enabled"`
	JWTSecret        string `yaml:"jwt_secret"`
	TokenExpireHours int    `yaml:"token_expire_hours"`
}

// TunnelSettings 隧道配置
type TunnelSettings struct {
	PersistenceEnabled bool              `yaml:"persistence_enabled"`
	PublicPortRange    PortRangeSettings `yaml:"public_port_range"`
	DefaultDomain      string            `yaml:"default_domain"`
}

// PortRangeSettings 端口范围配置
type PortRangeSettings struct {
	Min int `yaml:"min"`
	Max int `yaml:"max"`
}

// LoggingSettings 日志配置
type LoggingSettings struct {
	Level    string `yaml:"level"`
	SQLDebug bool   `yaml:"sql_debug"`
}

// DevelopmentSettings 开发模式配置
type DevelopmentSettings struct {
	MockMode      bool `yaml:"mock_mode"`
	SkipPortCheck bool `yaml:"skip_port_check"`
}

// DomainRouterSettings 域名路由器配置
type DomainRouterSettings struct {
	Enabled      bool `yaml:"enabled"`       // 是否启用域名路由器
	Port         int  `yaml:"port"`          // 监听端口（通常为80）
	ReadTimeout  int  `yaml:"read_timeout"`  // 读取超时（秒）
	WriteTimeout int  `yaml:"write_timeout"` // 写入超时（秒）
	IdleTimeout  int  `yaml:"idle_timeout"`  // 空闲超时（秒）
}

// DNSSettings DNSPod配置
type DNSSettings struct {
	Enabled  bool   `yaml:"enabled"`   // 是否启用DNSPod自动域名解析
	Domain   string `yaml:"domain"`    // 基础域名
	PublicIP string `yaml:"public_ip"` // 服务器公网IP地址
}

// TencentSettings 腾讯云配置
type TencentSettings struct {
	SecretID  string `yaml:"secret_id"`  // 腾讯云SecretId
	SecretKey string `yaml:"secret_key"` // 腾讯云SecretKey
}

// 全局配置实例
var AppConfig *ServerConfig

// LoadConfig 加载配置文件
func LoadConfig(configPath string) error {
	log.Printf("🔧 加载配置文件: %s", configPath)

	// 检查配置文件是否存在
	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		log.Printf("⚠️  配置文件不存在，创建默认配置文件: %s", configPath)
		if err := createDefaultConfig(configPath); err != nil {
			return fmt.Errorf("创建默认配置文件失败: %w", err)
		}
	}

	// 读取配置文件
	data, err := os.ReadFile(configPath)
	if err != nil {
		return fmt.Errorf("读取配置文件失败: %w", err)
	}

	// 解析YAML
	config := &ServerConfig{}
	if err := yaml.Unmarshal(data, config); err != nil {
		return fmt.Errorf("解析配置文件失败: %w", err)
	}

	// 验证配置
	if err := validateConfig(config); err != nil {
		return fmt.Errorf("配置验证失败: %w", err)
	}

	// 设置全局配置
	AppConfig = config

	log.Printf("✅ 配置加载成功")
	log.Printf("📋 配置摘要:")
	log.Printf("   HTTP端口: %d", config.Server.HTTPPort)
	log.Printf("   隧道端口: %d", config.Server.TunnelPort)
	log.Printf("   认证启用: %t", config.Auth.Enabled)
	log.Printf("   隧道持久化: %t", config.Tunnel.PersistenceEnabled)
	log.Printf("   运行模式: %s", config.Server.Mode)

	return nil
}

// createDefaultConfig 创建默认配置文件
func createDefaultConfig(configPath string) error {
	defaultConfig := &ServerConfig{
		Server: ServerSettings{
			HTTPPort:    8080,
			TunnelPort:  9001,
			HTTP2Port:   8081, // HTTP/2隧道端口
			EnableHTTP2: true, // 默认开启（已完成集成）
			Mode:        "debug",
		},
		Database: DatabaseSettings{
			Type:         "mysql",
			Host:         "127.0.0.1",
			Port:         3306,
			Username:     "root",
			Password:     "root",
			DBName:       "tunnel_db",
			MaxIdleConns: 10,
			MaxOpenConns: 100,
		},
		Auth: AuthSettings{
			Enabled:          true,
			JWTSecret:        "your-secret-key-here",
			TokenExpireHours: 168,
		},
		Tunnel: TunnelSettings{
			PersistenceEnabled: true,
			PublicPortRange: PortRangeSettings{
				Min: 10000,
				Max: 65535,
			},
			DefaultDomain: "tunnel.example.com",
		},
		Logging: LoggingSettings{
			Level:    "info",
			SQLDebug: false,
		},
		Development: DevelopmentSettings{
			MockMode:      false,
			SkipPortCheck: false,
		},
	}

	// 确保目录存在
	dir := filepath.Dir(configPath)
	if err := os.MkdirAll(dir, 0755); err != nil {
		return fmt.Errorf("创建配置目录失败: %w", err)
	}

	// 序列化为YAML
	data, err := yaml.Marshal(defaultConfig)
	if err != nil {
		return fmt.Errorf("序列化默认配置失败: %w", err)
	}

	// 写入文件
	if err := os.WriteFile(configPath, data, 0644); err != nil {
		return fmt.Errorf("写入配置文件失败: %w", err)
	}

	return nil
}

// validateConfig 验证配置
func validateConfig(config *ServerConfig) error {
	// 验证端口范围
	if config.Server.HTTPPort < 1 || config.Server.HTTPPort > 65535 {
		return fmt.Errorf("HTTP端口无效: %d", config.Server.HTTPPort)
	}
	if config.Server.TunnelPort < 1 || config.Server.TunnelPort > 65535 {
		return fmt.Errorf("隧道端口无效: %d", config.Server.TunnelPort)
	}

	// 验证运行模式
	if config.Server.Mode != "debug" && config.Server.Mode != "release" {
		return fmt.Errorf("运行模式无效: %s", config.Server.Mode)
	}

	// 验证数据库类型
	if config.Database.Type != "mysql" {
		return fmt.Errorf("不支持的数据库类型: %s", config.Database.Type)
	}

	// 验证公网端口范围
	if config.Tunnel.PublicPortRange.Min < 1024 || config.Tunnel.PublicPortRange.Max > 65535 {
		return fmt.Errorf("公网端口范围无效: %d-%d", config.Tunnel.PublicPortRange.Min, config.Tunnel.PublicPortRange.Max)
	}
	if config.Tunnel.PublicPortRange.Min >= config.Tunnel.PublicPortRange.Max {
		return fmt.Errorf("公网端口范围最小值必须小于最大值")
	}

	return nil
}

// IsAuthEnabled 检查是否启用认证
func IsAuthEnabled() bool {
	if AppConfig == nil {
		return true // 默认启用认证
	}
	return AppConfig.Auth.Enabled
}

// IsPersistenceEnabled 检查是否启用隧道持久化
func IsPersistenceEnabled() bool {
	if AppConfig == nil {
		return true // 默认启用持久化
	}
	return AppConfig.Tunnel.PersistenceEnabled
}

// GetHTTPPort 获取HTTP端口
func GetHTTPPort() int {
	if AppConfig == nil {
		return 8080
	}
	return AppConfig.Server.HTTPPort
}

// GetTunnelPort 获取隧道端口
func GetTunnelPort() int {
	if AppConfig == nil {
		return 9001
	}
	return AppConfig.Server.TunnelPort
}
